Ontologies are conceptualizations of the real world. The simplest way to capture knowledge present in the real world is to capture entities and interactions between them. The easiest way to achieve this is to capture interaction between any two entities. This is the simplest way to create a sentence in English, with subject, predicate and object. This is also called as a Triple as it involves three components (two entities and in indication of relationship between them). Any event in the real world can be captured with such simple sentences giving us such triples. Ontologies provide us a way to capture these entities and triples in a format that can be used further by machines for various purposes.
There are many standards proposed and in use for capturing Ontologies. Most of these standards are XML based in order to achieve platform independence and portability. The most commonly used standard is OWL/RDF or Web Ontology Language. OWL/RDF provides a reach schema in order to capture ontological information but at the same time is plagued with some shortcomings, such as scalability.
Ontological entities are generally categorized as Concepts, Relations and Instances. Concepts are the real world entities at a generic level, for example, Person, Car etc. Relations are the interactions between concepts; for example, Person drives a Car. Instances are the concretization of the concepts at different levels; for example, Honda is a Car, Toyota is a Car, John is a Person etc. Interactions are also called as Associations and they result into Triples i.e. Subject-Predicate-Object format. In the current example “Person-Drives-Car” is a triple with “Person” is the Subject, and thus the originator of the interaction, “Drives” is the predicate i.e. the defined interaction between the subject and the object, and Car becomes “Object” i.e. the entity on which the interaction is being performed. As one can see a triple gives an interaction possibility between two entities. Here it is important to note that the interaction is presented as a possibility only because not every person will drive every car. Hence, it is necessary to capture the interactions at actual Instance level as well. For example, John may drive only Honda and not Toyota. These Instance level interactions are captured as instance triples separately from the broader concept triples. Also it is important to note that concepts and instances are dependent on the context in which they are being modeled. This means, one can model Car as concept in context of auto-shopping and one can model the same Car as instance of a vehicle in case of travel context. Thus, depending on the generic nature of the context, concepts and instances are modeled.
There have been many efforts to store ontology information in other formats. Most common are the proposals to store ontology information in relational databases. There have also been efforts to store RDF graphs in relational databases. Most of these efforts like Sesame; RDQL etc. are triple centric approaches. They store triples as three columns in a table and most querying revolves around this structure. Most of these approaches assume that user is well versed with RDF and want to query in or using RDF like constructs. Additionally, this RDF based querying becomes slower and slower as the size of content being queried increases. As will be discussed below, the present application differs from prior solutions, enabling a common computer user to be able to ask questions without knowing how to query in RDF. These existing techniques have been evaluated many times, substantial literature being available describing them. An evaluation of existing ontology storage approaches is provided at “Ontology Storage and Querying” by Magkanaraki et.al. Similarly another proposal for storing RDF in a database can be found at “RDF Data-Centric Storage” by Levandoski et.al.
There are a few other approaches “Storage and Querying of E-Commerce Data” by R. Agrawal et.al., “From Ontology to Relational Databases” by A. Gali et.al., where Ontology may be stored as a relational database, where each class with properties becomes a Table and data-type properties become columns. Object properties are represented as foreign key constraints. Instances become rows in these tables. In this approach, even though querying in simpler than using EDF querying languages, one has to be well aware of the particular schema of the particular ontology and the resulting relational database is tightly coupled to that schema. In accordance with various embodiments of the present invention, a newer approach to store Ontology in relational databases is provided.
Therefore, it would be desirable to provide a method and apparatus that overcomes these noted drawbacks of the prior art and allows for efficient and effective storage of ontologies in a relational database.